import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: xwl
 * Date: 2023-05-05
 * Time: 20:47
 */
class main {
    public static void main(String[] args) {

    }
}
public class MyArrayList {
    public int[] elem;
    public int usedSize;//0
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public MyArrayList() {
        this.elem = new int[DEFAULT_SIZE];
    }

    /**
     * 打印顺序表:
     *   根据usedSize判断即可
     */
    public void display() {
        // 输出
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }

    /**
     * 插入数据，默认从表尾插入
     * @param data:待插入数据
     */
    public void add(int data) {
        // 判断数组是否已满
        if (isFull()) {
            resize();
        }
        // 插入
        this.elem[this.usedSize] = data;
        // 数组长度增加
        this.usedSize++;
    }

    /**
     * 为数组扩容
     */
    public void resize() {
        this.elem = Arrays.copyOf(this.elem,2 * this.elem.length);
    }


    /**
     * 判断当前的顺序表是不是满的！
     * @return true:满   false代表未满
     */
    public boolean isFull() {
        return this.usedSize == this.elem.length;
    }

    /**
     * 判断当前位置是否合法
     * @param pos:待检查的位置
     * @return true:合法时返回
     */
    private boolean checkPosInAdd(int pos) {
        if(pos < 0 || pos > usedSize) {
            throw new ArrayOutOfException("位置不合法");
        }
        return true;//合法
    }

    /**
     * 在 pos 位置前新增元素
     * @param pos:待插入的位置
     * @param data:待插入有的数据
     */
    public void add(int pos, int data) {
        // 判断插入位置是否合法
        checkPosInAdd(pos);
        // 判断数组是否已满
        if (isFull()) {
            resize();
        }
        // 实现
        for (int i = this.usedSize; i >= pos; i++) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        usedSize++;
    }

    /**
     * 判定是否包含某个元素
     * @param toFind:待查询数据
     * @return true:包含 false:不包含
     */
    public boolean contains(int toFind) {
        boolean bool = false;
        // 遍历查询
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                bool = true;
            }
        }
        return bool;
    }

    /**
     * 查找某个元素对应的位置
     * @param toFind:待查询数据
     * @return pos:第一个相对应元素所对应的位置
     */
    public int indexOf(int toFind) {
        contains(toFind);
        int pos = -1;
        // 遍历查询
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                pos = i;
            }
        }
        return pos;
    }

    /**
     * 获取 pos 位置的元素
     * @param pos
     * @return
     */
    public int get(int pos) {
        checkPosInAdd(pos);
        return this.elem[pos];
    }

    /**
     * 判断数组是否为空
     * @return false:不为空 true:为空
     */
    private boolean isEmpty() {
        if (this.usedSize == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 给 pos 位置的元素设为【更新为】 value
     * @param pos:待更新的位置
     * @param value:更新后的值
     */
    public void set(int pos, int value) {
        this.elem[pos] = value;
    }

    /**
     * 删除第一次出现的关键字key
     * @param key
     */
    public void remove(int key) {
        int index = indexOf(key);
        if (index == -1) {
            System.out.println("该元素不存在");
        }
        // 实现删除
        for (int i = this.usedSize - 1; i > index; i++) {
            this.elem[i-1] = this.elem[i];
        }
        this.usedSize--;
    }

    /**
     * @return this.usedSize:当前数组的长度
     */
    public int size() {
        return this.usedSize;
    }

    // 清空顺序表
    public void clear() {
        this.usedSize = 0;
    }
}